Method and application tool for dynamically navigating a user customizable representation of a network device configuration

ABSTRACT

In one embodiment of the invention, a method and an application tool for dynamically representing configuration commands of a network device on a user interface are provided. According to the method, a data model is stored with the application tool. Thereafter, the configuration commands are rendered on to the data model and the rendered data model is represented on the user interface in real time.

BACKGROUND OF THE INVENTION

1. Field of Invention

The present invention relates, in general, to network devices. Morespecifically, embodiments of the invention relate to methods and systemsfor customizing and dynamically navigating a representation of a networkdevice configuration.

2. Description of the Background Art

Various network devices are required for communication across networksand are configured so that they can communicate with other networkdevices. The configuration is accomplished using a configuration thatmay include the addresses of the devices, protocols for communication,handling inbound and outbound traffic, and so forth.

Conventionally, the configuration may be modified with the help of atext interface. One such text interface in wide use is referred to suchas a command line interface. A series of commands are entered line byline to the command line interface for this purpose. Because of thesheer size and complexity of the configuration it is often difficult toread and navigate, even if these configuration commands being modifiedare few in number.

Once a network device is deployed in a network, a network serviceprovider is often tasked with handling the modification of theconfiguration for a large number of network devices. It is also verydifficult for the service provider to understand the overall content,structure and relationship of these various configuration commands giventhe nuances of a complex network device. Further, with large, complexconfigurations, the task of identifying incomplete or inconsistentsections of the configuration becomes difficult.

It is also difficult to locate, navigate to or view desired portions ofconfiguration commands in scattered portions of the configuration. Whilelocating or navigating between portions of the configuration isdifficult even with a relatively small number of commands or lines ofcode, it is especially burdensome for configuration s having tens ofthousands of lines of code.

It is well recognized that modifying the configuration for a networkdevice is slow and often prone to programming errors. Thus, a system andmethod for representing configuration commands of a network device thatexpedites the task of modifying (or simply viewing and navigatingthrough) a configuration is clearly desirable.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates an environment for implementing an embodiment of theinvention.

FIG. 2 illustrates a block diagram of an application tool fordynamically representing configuration commands of a network device on auser interface, in accordance with an embodiment of the invention.

FIG. 3 illustrates a flowchart of a method for dynamically representingconfiguration commands of a network device on a user interface, inaccordance with an embodiment of the invention.

FIG. 4 illustrates a flowchart of a method for dynamically representingconfiguration commands of a network device on a user interface with thehelp of an expand-collapse check indicator, in accordance with anotherembodiment of the invention.

FIGS. 5 a and 5 b are partial screenshots of a user interface,illustrating an expand-collapse check indicator, in accordance with anembodiment of the invention.

FIG. 6 illustrates a flowchart of a method for dynamically representingconfiguration commands of a network device on a user interface with thehelp of a contextual-linkage, in accordance with an embodiment of thepresent invention.

FIG. 7 is a partial screenshot of a user interface illustrating acontextual-linkage, in accordance with an embodiment of the invention.

FIG. 8 is a partial screenshot of a user-editable used for definingcontextual-linkages, in accordance with an embodiment of the invention.

FIG. 9 illustrates a flowchart of a method for dynamically representingconfiguration commands of a network device on a user interface with thehelp of mismatch representation in a block, in accordance with anembodiment of the invention.

FIG. 10 is a partial screenshot illustrating a block mismatch, inaccordance with an embodiment of the invention.

DETAILED DESCRIPTION OF EMBODIMENTS OF THE INVENTION

The embodiments of the invention provide a method and an applicationtool for dynamically representing configuration commands of a networkdevice on a user interface. In the description herein for embodiments ofthe present invention, numerous specific details have been provided,such as examples of components and/or methods, to provide a thoroughunderstanding of embodiments of the present invention. One skilled inthe relevant art will recognize, however, that an embodiment of theinvention can be practiced without one or more of the specific details,or with other apparatus, systems, assemblies, methods, components,materials, parts, and/or so forth. In other instances, well-knownstructures, materials, or operations are specifically not shown ordescribed in detail to avoid obscuring aspects of embodiments of thepresent invention.

Computer networks comprise various network devices that must beconfigured to perform specific functions in networks. A configurationdescribes the physical configuration of the network and typicallycontains at least one line for each switch in the network. For largenetworks, the configuration will be very large, often comprising tens ofthousands of lines of code information. Thus, navigating andunderstanding the configuration is difficult due to the sheer size ofthe configuration.

In accordance with the present invention, enhancements are overlaid ontop of the text interface to allow users to dynamically customize theirview of a device's configuration. The enhancements offer the user theability to control how the view and navigate configurations to fit theirindividual needs.

In accordance with the present invention, an application tool stores adata model of the configuration for a network device. The configurationcontains the configuration commands required for configuring the networkdevice. The application tool renders the configuration commands based onthe data model and a set of contextual linkage rules to generate a userinterface that represents the configuration in a user-friendly manner.In one embodiment of the invention, the configuration is rendered suchthat related lines of code that may not be in a contiguous block aredynamically linked to each other by a contextual-linkage. Thiscontextual-linkage is used to link and easily navigate between relatedconfiguration commands. A graphical pop-up box, representing a snapshotof the linked configuration command, is displayed next to thecontextual-linkage so that the user does not have to physically scrollto the linked command.

In another embodiment of the invention, the configuration commands arerendered such that one or more nested configuration commands are eitherhidden or displayed on the user interface, based on the selection of anexpand-collapse check indicator.

In yet another embodiment of the invention, the configuration commandsare rendered such that all nested configuration commands aresimultaneously either hidden or displayed on the user interface, basedon the selection of an “all-blocks” expand-collapse check indicator.

In yet another embodiment of the invention, the configuration commandsare rendered such that a mismatch in a block of configuration commandsis dynamically identified and displayed on the user interface to assistin correcting programming errors.

Referring now to the drawings, particularly by the respective referencenumbers, FIG. 1 illustrates an environment 100 for implementing anembodiment of the invention. Environment 100 includes a network 102.Examples of network 102 include, but are not limited to, the Internet, aLocal Area Network (LAN), a Wide Area Network (WAN), a Virtual PrivateNetwork (VPN), a client server network, and a peer-to-peer network.Network 102 comprises a plurality of network devices 104. Networkdevices 104 are connected in a manner that enables the transfer of datafrom one network device 104 to another across network 102. Examples ofnetwork devices 104 include, but are not limited to, gateways, routers,bridges, switches, hubs, and repeaters. Network devices 104 possess alarge number of features related to, by way of illustration, protocolimplementation, setting the method for authentication, setting themethod for allowing selective access to different users, and so forth.These features as well as the manner in which the network device 104will function are determined by the commands contained in aconfiguration 106 associated with each network device 104.

A management station 108 is used to generate a set of commands, known asthe configuration commands, for configuring network device 104 using atext interface. Management station 108 comprises a user interface 110for generating the configuration commands. These configuration commandsare transferred on to network device 104 to replace, for example, apre-existing configuration with a modified configuration. Modificationsin configuration 106 are carried out after transferring configuration106 from a selected one of the network devices 104 to management station108. Thereafter, the modified configuration commands are loaded on tonetwork device 104. In an alternative embodiment of the invention,modification of configuration 106 is carried out directly on networkdevice 104 without the need to transfer configuration 106 to themanagement station 108.

FIG. 2 illustrates a block diagram of an application tool 200 fordynamically representing configuration commands of network device 104 onuser interface 110, in accordance with an embodiment of the invention.Application tool 200 preferably executes on management station 108 andcomprises memory 202 for storing the configuration 106, a text interface204 for modifying command lines in configurations 106, rendering editor206 and a representation module 208. Memory 202 stores a data model ofthe configuration commands. Examples of memory 202 includes, but are notlimited to, a cache memory, a flash memory, a hard disc, a floppy disc,and an optical memory. The data model comprises the meaning of eachconfiguration commands. In addition, the data model includes therelationships between the various configuration commands. The textinterface 204 is used to modify the data model.

Rendering editor 206 interfaces with text interface 204 to render theconfiguration commands on the data model. Rendering, in this case,refers to parsing one or more configuration commands, based on the datamodel. For example, rendering implies watching out for errors in theconfiguration commands. In addition, rendering editor 206 dynamicallycarries out this rendering. Therefore, if any modifications are carriedout on the configuration commands, rendering editor 206 dynamicallyrenders the modifications on the data model so that the results of themodifications are provided on user interface 110 in real-time.

Representation module 208 represents the data model on user interface108. In addition, representation module 208 handles user interactions.For example, if the user modifies one or more configuration commands,the representation module 208 dynamically provides the informationregarding the modifications to rendering editor 206. Additionally,representation module 208 represents the results of these modificationsin the data model on user interface 108.

FIG. 3 illustrates a flowchart of a method for dynamically representingconfiguration commands of network device 104 on user interface 108, inaccordance with an embodiment of the invention. Application tool 200acquires a data model and configuration commands from network device104. At 302, the data model is stored in memory 202, which also storesthe configuration commands that have been added, deleted or modified onuser interface 108. Thereafter, at 304, the configuration commands arerendered on the data model. Rendering comprises parsing of one or morecommands from the configuration commands. In an embodiment, renderingcomprises searching for errors in the configuration commands. At 306,the data model is represented on user interface 108 by representationmodule 208. Representation module 208 indicates the presence or absenceof one or more configuration commands on user interface 108.Additionally, representation module 208 indicates the presence of erroron user interface 108.

FIG. 4 illustrates a flowchart of a method for dynamically representingconfiguration commands of network device 104 on user interface 108 withthe help of an expand-collapse check indicator, in accordance withanother embodiment of the invention. Typically, the configurationcomprises a hierarchy of configuration commands represented by indents.

At 402, the hierarchical structure is identified in the data model byrendering editor 206. At 404, representation module 208 can display anexpand-collapse check indicator for each level in the hierarchicalstructure. At 406, representation module 208 detects that theexpand-collapse check indicator has been selected. At 408,representation module 208 controls the representation of the datahierarchy. In this case, the representation is controlled by dynamicallycollapsing the configuration commands, such that all configurationcommands lower in the hierarchy are not visible on user interface 108.Although these commands are not visible on user interface 108, thesecommands exist in data model. Therefore, viewing features, such as findand replace, can be used for these commands even when these commands arenot visible.

When representation module 208 detects a re-selection of theexpand-collapse check indicator, the collapsed commands are dynamicallyexpanded by representation module 208. Thereafter, the collapsedcommands are visible on user interface 108. In this manner, a user canquickly scan a collapsed view of a large configuration to locaterelevant portions that require modification. Once the relevant portionis located, the portion can be expanded to show the hierarchical view ofthe commands. Furthermore, with any addition, deletion or modificationto the hierarchy, the expand-collapse check indicators are changeddynamically by rendering editor 206 and dynamically represented byrepresentation module 208.

FIGS. 5 a and 5 b are two screenshots of user interface 108 illustratingan expand-collapse check indicator 502 a and 502 b respectively, inaccordance with an embodiment of the invention. In FIG. 5 a,expand-collapse check indicator 502 a is displayed. When a user selectsexpand-collapse check indicator 502 a, the configuration commands thatare lower in hierarchy than the selected level are collapsed and arehidden from the user. The user selects expand-collapse check indicator502 a by using a mouse. In an embodiment, expand-collapse checkindicator 502 a is selected by using a keyboard. Conversely, when theuser selects expand-collapse check indicator 502 b, the commands, thatwere collapsed, are expanded and are made visible to the user.

In another embodiment of the invention (not illustrated), theconfiguration commands are rendered such that all nested configurationcommands are simultaneously either hidden (collapsed) or displayed(expanded) on the user interface, based on the selection of an“all-blocks” expand-collapse check indicator. Preferably, this“all-blocks” expand-collapse indicator is located in the ConfigurationControls portion 504 of the tool bar.

FIG. 6 illustrates a flowchart of a method for dynamically representingconfiguration commands of network device 104 on user interface 108 withthe help of a contextual-linkage, in accordance with an embodiment ofthe present invention. Contextual-linkage refers to links that arerendered in the visual representation to show the user when a piece ofconfiguration (referred to as the source anchor) refers to another pieceof configuration (referred to as the destination anchor) locatedelsewhere in the configuration. The contextual links are defined byrules. The rules, which define the pieces of configuration that arerelated and should be linked, are maintained in a user-editable file.This allows the user to customize the linkages for their specific needsand environment without code changes, and have the rules becomedynamically active without reinitializing operation of the applicationtool 200. The rules defining the linked configuration commands arestored in memory 202.

At 602, rendering editor 206 uses the rules file to link a destinationanchor to a source anchor, where source anchor and destination anchorare configuration commands. Once the commands are linked, a user cannavigate from the source anchor to the destination anchor without havingto search through the configuration. The contextual-linkages are definedseparately for each user that may access the configuration on networkdevice 104. Therefore, a user may link commands as per individualrequirements. The user defines the contextual-linkage on a user-editablefile, which is stored in memory 202. The user can dynamically modifythis user-editable file as per his requirements.

Whenever a modification is accepted on the user-editable file or on theconfiguration, the modification is dynamically parsed by renderingeditor 206. Rendering editor 206 dynamically modifies or removes analready existing contextual-linkage, or adds a new contextual-linkagebased on accepted modifications to the user-editable rules file or themodifications to the configuration.

At 604, representation module 208 displays a source anchor that has beendistinguished to indicate the contextual-linkage. The contextual-linkagemay be distinguished from other configuration commands by, for example,highlighting the link or by use of different color. At 606,representation module 208 detects the selection of thecontextual-linkage by the user. Subsequently, at 608, representationmodule 208 navigates to the destination anchor corresponding to thesource anchor. To illustrate, if a user wishes to modify theconfiguration, the present invention allows a user to expand or collapsethe hierarchical command structure of the to quickly locate a particularportion of the configuration by collapsing the hierarchical structure toobtain a global view and then to zoom in on the portion of interest byselecting the appropriate expand indicator. Once the user is viewing theportion of configuration, the user may use the simplified navigationbetween linked sections of the configuration to easily view or modifythe configuration.

In another embodiment, memory 202 stores the details of the lastselected contextual-linkage. Representation module 208 provides for aprovision such as a button, to return to this stored contextual-linkage.Therefore, the user can quickly and easily navigate between the sourceanchor and the destination anchor across configuration 106.

FIG. 7 is a screenshot of user interface 108 illustrating acontextual-linkage 702, in accordance with an embodiment of theinvention. A source anchor 702 is graphically represented ascontextual-linked to a destination anchor. When a pointer is detectednear source anchor 702, a graphical box, referred to as a tooltip 704,is displayed near the pointer. Tooltip 704 displays a snapshot of thedestination anchor where the snapshot includes the entire portion of theconfiguration associated with the destination anchor. When tooltip 704is selected by moving the pointer over tooltip 704, representationmodule 208 navigates to the location of the destination anchor anddisplays all of the lines of the destination anchor. The user is thenshown on their display device the portion of the configuration where thedestination anchor is located. The user selects tooltip 704 by using amouse or other indicating means. In another embodiment, source anchor702 is selected by using a keyboard.

The details of the source anchor are stored by memory 202. In addition,a return button 706 is provided. When representation module 208 detectsthe selection of button 706, it returns to the source anchor 702. Thisenables the user to seamlessly navigate between portions of theconfiguration where the source anchor and the destination anchor arelocated. Advantageously, the user need not scroll through theconfiguration to find related commands.

Adjacent to button 706, an optional button (not illustrated) may beprovided in some embodiments such that contextual-linkages can beselectively displayed or not displayed depending on the user's desire.

The rules for which pieces of configuration are related and subject tocontextual-linkage are defined in a user-editable file such asillustrated at 800 in FIG. 8, in accordance with an embodiment of theinvention. This file allows the user to define and customize thelinkages for their specific needs and environment without code changes,and have the linkages dynamically become active without restarting theapplication tool. More specifically, the user editablecontextual-linkage rules file comprises the details of the linkedconfiguration commands that are to be linked in a configuration 106. Theuser editable-file is preferably stored in computer-readable medium andis associated with a specific configuration 106 and network device 104.

An example of a Contextual-linkage Rules File contents are as follows:

<interface *> : <interface *>

<usergroup *> : <group *>

<ipv4 prefix-list *> : <prefix-list *>

The ‘destination anchor’ is the line of text that allcontextual-linkages will reference. In an embodiment, eachcontextual-linkage rule entry is preferably in the format: <destinationanchor *>: <source anchor *>. It will be appreciated that other formatsfor contextual-linkage rules are readily envisioned. Such rule formatsare, in other embodiments, determined by engineering considerations andare not further discussed herein.

The “*” represents a single word that must be the identical match forthe contextual-linkage to be formed. Using the following rule as anexample:

<interface *> : <interface *>

Then, any instance of “interface MgmtEth0/0/CPU0/0” is thecontextual-linkage for the destination anchor “interfaceMgmtEth0/0/CPU0/0”. However, “interface MgmtEth0/0/CPU0/0” will not bethe contextual linkage for the source anchor “interface POS0/1/0/0”.

To further illustrate, the user can link a source anchor 802 to adestination anchor 804. Whenever text interface 204 finds source anchor802, text interface 204 searches configuration 106 for destinationanchor 804. If destination anchor 804 is found in configuration 106,source anchor 802 is linked to destination anchor 804. As explained inconjunction with FIG. 7, the contextual-linkage is indicated by visuallydistinguishing the source anchor 802 to indicate the contextual link todestination anchor 804.

FIG. 9 illustrates a flowchart of a method for dynamically representingconfiguration commands of network device 104 on user interface 108 withthe help of mismatch representation in a block, in accordance with anembodiment of the invention. A block is defined as a set ofconfiguration commands that begins with a starting configuration commandand terminates with an ending configuration command. The configurationcommands present between the starting configuration command and theending configuration command are referred to as the body configurationcommands. The details of the various blocks are present in the datamodel.

At 902, rendering editor 206 identifies a mismatch in the block. Themismatch may be detected by the absence of a corresponding endingconfiguration command for a starting configuration command or viceversa. Indentation of the configuration commands following the startingconfiguration command may be compared to identify this mismatch. Ifanother starting configuration command is detected before an endingconfiguration command, then a mismatch is declared. Furthermore, thesemismatches are identified in real-time. Therefore, whenever amodification to a configuration command is accepted, rendering editor206 searches for a mismatch.

At 904, representation module 208 indicates the mismatch on userinterface 108. Highlighting is preferably used to indicate the mismatch.As mentioned earlier, the identification of the mismatch is performed inreal-time. Therefore, if a mismatch is identified, it is dynamicallyrepresented by representation module 208. At 906, rendering editor 206may suggest corrective action to eliminate detected mismatches by, forexample, suggesting placement for an ending configuration command.

FIG. 10 is a screenshot illustrating a block mismatch, in accordancewith an embodiment of the invention. An ‘elseif’ command 1002 is astarting configuration command. The corresponding ending configurationcommand is defined as ‘endif’. When an ‘endif’ command is notencountered by the rendering editor 206, representation module 208highlights ‘elseif’ command 1002. Furthermore, as the identification ofa mismatch is carried out dynamically, when an ‘endif’ command isaccepted on user-interface 108 corresponding to ‘elseif’ command 1002,the mismatch is no longer indicated.

Various embodiments of the invention provide a method for dynamicallyrepresenting configuration commands of a network device on a userinterface using an application tool. The method comprising: storing adata model, wherein the data model represents the configurationcommands; rendering the configuration commands on the data model; andrepresenting the rendered data model on the user interface.

According to another embodiment of the invention, an application toolconfigured for dynamically representing configuration commands of anetwork device on a user interface is provided. The application toolcomprising: a storing module for storing a data model, wherein the datamodel represents the configuration commands; a rendering editor forrendering the data model; and a representation module for representingthe rendered data model on the user interface.

According to still another embodiment of the invention, an apparatus fordynamically representing configuration commands of a network device on auser interface is provided. The apparatus comprising: a processingsystem including a processor coupled to a display and user input device;and a machine-readable medium including instructions executable by theprocessor. The instructions comprising means for storing a data model,wherein the data model represents the configuration commands; means forrendering the configuration commands on the data model; and means forrepresenting the rendered data model on the user interface.

Embodiments of the invention provide a method and an application toolfor dynamically representing configuration commands of a network deviceon a user interface. Embodiments of the invention provide simplifiedviewing of the configuration by dynamic expanding and collapsing theconfiguration commands. In addition, embodiments of the inventionprovide dynamic linking of two configuration commands. This facilitatessimplified viewing and navigation between the configuration commands.Additionally, embodiments of the invention assist in debugging of errorsby dynamically indicating mismatches in blocks of configurationcommands.

In the discussions of the invention discussed with respect to thevarious embodiments refer to network device; however one skilled in theart will appreciate that the system and methods described herein arealso applicable to network appliances, servers or clients.

Although the invention has been discussed with respect to specificembodiments thereof, these embodiments are merely illustrative, and notrestrictive, of the invention.

In the description herein, numerous specific details are provided, suchas examples of components and/or methods, to provide a thoroughunderstanding of embodiments of the invention. One skilled in therelevant art will recognize, however, that an embodiment of theinvention can be practiced without one or more of the specific details,or with other apparatus, systems, assemblies, methods, components,materials, parts, and/or the like. In other instances, well-knownstructures, materials, or operations are not specifically shown ordescribed in detail to avoid obscuring aspects of embodiments of theinvention.

Reference throughout this specification to “one embodiment”, “anembodiment”, or “a specific embodiment” means that a particular feature,structure, or characteristic described in connection with the embodimentis included in at least one embodiment of the invention and notnecessarily in all embodiments. Thus, respective appearances of thephrases “in one embodiment”, “in an embodiment”, or “in a specificembodiment” in various places throughout this specification are notnecessarily referring to the same embodiment. Furthermore, theparticular features, structures, or characteristics of any specificembodiment of the present invention may be combined in any suitablemanner with one or more other embodiments. It is to be understood thatother variations and modifications of the embodiments of the presentinvention, described and illustrated herein, are possible in light ofthe teachings herein and are to be considered as part of the spirit andscope of the present invention.

The foregoing description of illustrated embodiments of the presentinvention, including what is described in the Abstract, is not intendedto be exhaustive or to limit the invention to the precise formsdisclosed herein. While specific embodiments of, and examples for, theinvention are described herein for illustrative purposes only, variousequivalent modifications are possible within the spirit and scope of thepresent invention, as those skilled in the relevant art will recognizeand appreciate. As indicated, these modifications may be made to thepresent invention in light of the foregoing description of illustratedembodiments of the present invention and are to be included within thespirit and scope of the present invention.

As used in the description herein and throughout the claims that follow,“a”, “an”, and “the” includes plural references unless the contextclearly dictates otherwise. Also, as used in the description herein andthroughout the claims that follow, the meaning of “in” includes “in” and“on” unless the context clearly dictates otherwise.

It will also be appreciated that one or more of the elements depicted inthe drawings/figures can also be implemented in a more separated orintegrated manner, or even removed or rendered as inoperable in certaincases, as is useful in accordance with a particular application. It isalso within the spirit and scope of the present invention to implement aprogram or executable code that can be stored in a machine-readablemedium to permit a computer to perform any of the methods describedabove.

Additionally, any signal arrows in the drawings/Figures should beconsidered only as exemplary, and not limiting, unless otherwisespecifically noted. Furthermore, the term “or” as used herein isgenerally intended to mean “and/or” unless otherwise indicated.Combinations of components or steps will also be considered as beingnoted, where terminology is foreseen as rendering the ability toseparate or combine is unclear.

Embodiments of the invention may be implemented by using a programmedgeneral purpose digital computer, by using application specificintegrated circuits, programmable logic devices, field programmable gatearrays, optical, chemical, biological, quantum or nano-engineeredsystems, components and mechanisms may be used. In general, thefunctions of the present invention can be achieved by any means as isknown in the art. Distributed, or networked systems, components andcircuits can be used. Communication, or transfer, of data may be wired,wireless, or by any other means.

A “computer-readable medium” for purposes of embodiments of the presentinvention may be any medium that can contain, store, communicate,propagate, or transport the program for use by or in connection with theinstruction execution system, apparatus, system or device. The computerreadable medium can be, by way of example only but not by limitation, anelectronic, magnetic, optical, electromagnetic, infrared, orsemiconductor system, apparatus, system, device, propagation medium, orcomputer memory.

Any suitable programming language can be used to implement the routinesof the present invention including C, C++, Java, assembly language, etc.Different programming techniques can be employed such as procedural orobject oriented. The routines can execute on a single processing deviceor multiple processors. Although the steps, operations or computationsmay be presented in a specific order, this order may be changed indifferent embodiments. In some embodiments, multiple steps shown assequential in this specification can be performed at the same time.

Thus, while the present invention has been described herein withreference to particular embodiments thereof, a latitude of modification,various changes and substitutions are intended in the foregoingdisclosures, and it will be appreciated that in some instances somefeatures of embodiments of the invention will be employed without acorresponding use of other features without departing from the scope andspirit of the invention as set forth. Therefore, many modifications maybe made to adapt a particular situation or material to the essentialscope and spirit of the present invention. It is intended that theinvention not be limited to the particular terms used in followingclaims and/or to the particular embodiment disclosed as the best modecontemplated for carrying out this invention, but that the inventionwill include any and all embodiments and equivalents falling within thescope of the appended claims.

1. A method for dynamically representing the configuration of a networkdevice on a user interface, the method comprising: storing a data model,wherein the data model represents the visual presentation of theconfiguration; rendering the configuration based on the data model toprovide a dynamically customized view of the configuration; and visuallyrepresenting the rendered configuration.
 2. The method according toclaim 1 further comprising acquiring a configuration.
 3. The methodaccording to claim 1 further comprising using the data model to allowdynamic navigation of the configuration.
 4. The method according toclaim 1, wherein the rendering comprises linking a source anchor to adestination anchor.
 5. The method according to claim 4, wherein thelinking further comprises: defining rules regarding contextual-linkage;and parsing the rules to link the source anchor and the destinationanchor.
 6. The method according to claim 5, wherein the displayingfurther comprises: accepting at least one modification to the rules fromthe user interface; and dynamically displaying the contextual-linkagebased on the at least one modification to the rules.
 7. The methodaccording to claim 5, wherein the displaying further comprises:accepting modification to the configuration; and dynamically designatingportions of the modified configuration that matches one of the rules toindicate the contextual linkage.
 8. The method according to claim 5wherein the contextual-linkage rules are persistent.
 9. The methodaccording to claim 4 further comprising: displaying the source anchor;detecting a selected source anchor; and navigating to the destinationanchor linked to the selected source anchor.
 10. The method according toclaim 9 further comprising: detecting a pointer positioned proximate tothe contextual-linkage; and displaying a snapshot of the destinationanchor.
 11. The method according to claim 1, wherein the renderingcomprises: identifying data hierarchy in the data model, the datahierarchy comprising a plurality of levels; and displaying anexpand-collapse check indicator at each level in the hierarchy, whereinthe expand-collapse check indicator is used for controlling therepresentation of the data hierarchy; and detecting a selection of theexpand-collapse check indicator.
 12. The method according to claim 11further comprising using the expand-collapse check indicator and thedata model to navigate the configuration.
 13. The method according toclaim 1, wherein the rendering further comprises: identifying a mismatchin a block of configuration commands, the block comprising a startingconfiguration command, an ending configuration command and one or morebody configuration commands; and indicating the mismatch.
 14. The methodaccording to claim 13 further comprising: accepting modifications in theblock; and indicating the mismatch for the modified block, wherein themismatch is dynamically indicated when modifications are accepted. 15.The method according to claim 11, wherein the rendering furthercomprises: identifying a mismatch in a block of configuration commands,the block comprising a starting configuration command, an endingconfiguration command and one or more body configuration commands; andindicating the mismatch.
 16. An application tool for dynamicallyrepresenting the configuration of a network device, the application toolcomprising: a data model that determines the visual representation ofthe configuration; and means for rendering linked portions of theconfiguration.
 17. The application tool according to claim 16, whereinthe linked portions of the configuration comprise a source anchor and adestination anchor.
 18. The application tool according to claim 16,further comprising rules for defining the linked portions of theconfiguration.
 19. The application tool according to claim 16, whereinthe source anchor comprises a visually distinctive representation in afirst display mode and a non-distinctive representation in a seconddisplay mode.
 20. The application tool according to claim 19, furthercomprising: a pointer for selecting the contextual-linkage in the firstdisplay mode. means for displaying a snapshot of the destination anchor.21. The application tool according to claim 16, wherein the means forrendering identifies a data hierarchy in the data model.
 22. Theapplication tool according to claim 21, wherein the means for renderingidentifies a mismatch in a portion of the configuration.
 23. Theapplication tool according to claim 20 wherein the rules defining thelinked portions of the configuration are persistent.
 24. A method fordynamically navigating a network device configuration comprising:generating a model for displaying a configuration; navigating to adesired section; viewing the desired section together with a linkedportion of the configuration.
 25. The method of claim 24 furthercomprising: providing persistent, user customized, rules for dynamicallychanging the visual represenatation of the configuration when displayed.26. The method of claim 25 further comprising: editing theconfiguration; and identifying incomplete and inconsistent sectionswhile editing